home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / cgroup.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  12.5 KB  |  429 lines
  1. #ifndef _LINUX_CGROUP_H
  2. #define _LINUX_CGROUP_H
  3. /*
  4.  *  cgroup interface
  5.  *
  6.  *  Copyright (C) 2003 BULL SA
  7.  *  Copyright (C) 2004-2006 Silicon Graphics, Inc.
  8.  *
  9.  */
  10.  
  11. #include <linux/sched.h>
  12. #include <linux/cpumask.h>
  13. #include <linux/nodemask.h>
  14. #include <linux/rcupdate.h>
  15. #include <linux/cgroupstats.h>
  16. #include <linux/prio_heap.h>
  17. #include <linux/rwsem.h>
  18.  
  19. #ifdef CONFIG_CGROUPS
  20.  
  21. struct cgroupfs_root;
  22. struct cgroup_subsys;
  23. struct inode;
  24. struct cgroup;
  25.  
  26. extern int cgroup_init_early(void);
  27. extern int cgroup_init(void);
  28. extern void cgroup_lock(void);
  29. extern bool cgroup_lock_live_group(struct cgroup *cgrp);
  30. extern void cgroup_unlock(void);
  31. extern void cgroup_fork(struct task_struct *p);
  32. extern void cgroup_fork_callbacks(struct task_struct *p);
  33. extern void cgroup_post_fork(struct task_struct *p);
  34. extern void cgroup_exit(struct task_struct *p, int run_callbacks);
  35. extern int cgroupstats_build(struct cgroupstats *stats,
  36.                 struct dentry *dentry);
  37.  
  38. extern struct file_operations proc_cgroup_operations;
  39.  
  40. /* Define the enumeration of all cgroup subsystems */
  41. #define SUBSYS(_x) _x ## _subsys_id,
  42. enum cgroup_subsys_id {
  43. #include <linux/cgroup_subsys.h>
  44.     CGROUP_SUBSYS_COUNT
  45. };
  46. #undef SUBSYS
  47.  
  48. /* Per-subsystem/per-cgroup state maintained by the system. */
  49. struct cgroup_subsys_state {
  50.     /* The cgroup that this subsystem is attached to. Useful
  51.      * for subsystems that want to know about the cgroup
  52.      * hierarchy structure */
  53.     struct cgroup *cgroup;
  54.  
  55.     /* State maintained by the cgroup system to allow
  56.      * subsystems to be "busy". Should be accessed via css_get()
  57.      * and css_put() */
  58.  
  59.     atomic_t refcnt;
  60.  
  61.     unsigned long flags;
  62. };
  63.  
  64. /* bits in struct cgroup_subsys_state flags field */
  65. enum {
  66.     CSS_ROOT, /* This CSS is the root of the subsystem */
  67. };
  68.  
  69. /*
  70.  * Call css_get() to hold a reference on the cgroup;
  71.  *
  72.  */
  73.  
  74. static inline void css_get(struct cgroup_subsys_state *css)
  75. {
  76.     /* We don't need to reference count the root state */
  77.     if (!test_bit(CSS_ROOT, &css->flags))
  78.         atomic_inc(&css->refcnt);
  79. }
  80. /*
  81.  * css_put() should be called to release a reference taken by
  82.  * css_get()
  83.  */
  84.  
  85. extern void __css_put(struct cgroup_subsys_state *css);
  86. static inline void css_put(struct cgroup_subsys_state *css)
  87. {
  88.     if (!test_bit(CSS_ROOT, &css->flags))
  89.         __css_put(css);
  90. }
  91.  
  92. /* bits in struct cgroup flags field */
  93. enum {
  94.     /* Control Group is dead */
  95.     CGRP_REMOVED,
  96.     /* Control Group has previously had a child cgroup or a task,
  97.      * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
  98.     CGRP_RELEASABLE,
  99.     /* Control Group requires release notifications to userspace */
  100.     CGRP_NOTIFY_ON_RELEASE,
  101. };
  102.  
  103. struct cgroup {
  104.     unsigned long flags;        /* "unsigned long" so bitops work */
  105.  
  106.     /* count users of this cgroup. >0 means busy, but doesn't
  107.      * necessarily indicate the number of tasks in the
  108.      * cgroup */
  109.     atomic_t count;
  110.  
  111.     /*
  112.      * We link our 'sibling' struct into our parent's 'children'.
  113.      * Our children link their 'sibling' into our 'children'.
  114.      */
  115.     struct list_head sibling;    /* my parent's children */
  116.     struct list_head children;    /* my children */
  117.  
  118.     struct cgroup *parent;    /* my parent */
  119.     struct dentry *dentry;          /* cgroup fs entry */
  120.  
  121.     /* Private pointers for each registered subsystem */
  122.     struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
  123.  
  124.     struct cgroupfs_root *root;
  125.     struct cgroup *top_cgroup;
  126.  
  127.     /*
  128.      * List of cg_cgroup_links pointing at css_sets with
  129.      * tasks in this cgroup. Protected by css_set_lock
  130.      */
  131.     struct list_head css_sets;
  132.  
  133.     /*
  134.      * Linked list running through all cgroups that can
  135.      * potentially be reaped by the release agent. Protected by
  136.      * release_list_lock
  137.      */
  138.     struct list_head release_list;
  139.  
  140.     /* pids_mutex protects the fields below */
  141.     struct rw_semaphore pids_mutex;
  142.     /* Array of process ids in the cgroup */
  143.     pid_t *tasks_pids;
  144.     /* How many files are using the current tasks_pids array */
  145.     int pids_use_count;
  146.     /* Length of the current tasks_pids array */
  147.     int pids_length;
  148. };
  149.  
  150. /* A css_set is a structure holding pointers to a set of
  151.  * cgroup_subsys_state objects. This saves space in the task struct
  152.  * object and speeds up fork()/exit(), since a single inc/dec and a
  153.  * list_add()/del() can bump the reference count on the entire
  154.  * cgroup set for a task.
  155.  */
  156.  
  157. struct css_set {
  158.  
  159.     /* Reference count */
  160.     atomic_t refcount;
  161.  
  162.     /*
  163.      * List running through all cgroup groups in the same hash
  164.      * slot. Protected by css_set_lock
  165.      */
  166.     struct hlist_node hlist;
  167.  
  168.     /*
  169.      * List running through all tasks using this cgroup
  170.      * group. Protected by css_set_lock
  171.      */
  172.     struct list_head tasks;
  173.  
  174.     /*
  175.      * List of cg_cgroup_link objects on link chains from
  176.      * cgroups referenced from this css_set. Protected by
  177.      * css_set_lock
  178.      */
  179.     struct list_head cg_links;
  180.  
  181.     /*
  182.      * Set of subsystem states, one for each subsystem. This array
  183.      * is immutable after creation apart from the init_css_set
  184.      * during subsystem registration (at boot time).
  185.      */
  186.     struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
  187. };
  188.  
  189. /*
  190.  * cgroup_map_cb is an abstract callback API for reporting map-valued
  191.  * control files
  192.  */
  193.  
  194. struct cgroup_map_cb {
  195.     int (*fill)(struct cgroup_map_cb *cb, const char *key, u64 value);
  196.     void *state;
  197. };
  198.  
  199. /* struct cftype:
  200.  *
  201.  * The files in the cgroup filesystem mostly have a very simple read/write
  202.  * handling, some common function will take care of it. Nevertheless some cases
  203.  * (read tasks) are special and therefore I define this structure for every
  204.  * kind of file.
  205.  *
  206.  *
  207.  * When reading/writing to a file:
  208.  *    - the cgroup to use is file->f_dentry->d_parent->d_fsdata
  209.  *    - the 'cftype' of the file is file->f_dentry->d_fsdata
  210.  */
  211.  
  212. #define MAX_CFTYPE_NAME 64
  213. struct cftype {
  214.     /* By convention, the name should begin with the name of the
  215.      * subsystem, followed by a period */
  216.     char name[MAX_CFTYPE_NAME];
  217.     int private;
  218.  
  219.     /*
  220.      * If non-zero, defines the maximum length of string that can
  221.      * be passed to write_string; defaults to 64
  222.      */
  223.     size_t max_write_len;
  224.  
  225.     int (*open)(struct inode *inode, struct file *file);
  226.     ssize_t (*read)(struct cgroup *cgrp, struct cftype *cft,
  227.             struct file *file,
  228.             char __user *buf, size_t nbytes, loff_t *ppos);
  229.     /*
  230.      * read_u64() is a shortcut for the common case of returning a
  231.      * single integer. Use it in place of read()
  232.      */
  233.     u64 (*read_u64)(struct cgroup *cgrp, struct cftype *cft);
  234.     /*
  235.      * read_s64() is a signed version of read_u64()
  236.      */
  237.     s64 (*read_s64)(struct cgroup *cgrp, struct cftype *cft);
  238.     /*
  239.      * read_map() is used for defining a map of key/value
  240.      * pairs. It should call cb->fill(cb, key, value) for each
  241.      * entry. The key/value pairs (and their ordering) should not
  242.      * change between reboots.
  243.      */
  244.     int (*read_map)(struct cgroup *cont, struct cftype *cft,
  245.             struct cgroup_map_cb *cb);
  246.     /*
  247.      * read_seq_string() is used for outputting a simple sequence
  248.      * using seqfile.
  249.      */
  250.     int (*read_seq_string)(struct cgroup *cont, struct cftype *cft,
  251.                    struct seq_file *m);
  252.  
  253.     ssize_t (*write)(struct cgroup *cgrp, struct cftype *cft,
  254.              struct file *file,
  255.              const char __user *buf, size_t nbytes, loff_t *ppos);
  256.  
  257.     /*
  258.      * write_u64() is a shortcut for the common case of accepting
  259.      * a single integer (as parsed by simple_strtoull) from
  260.      * userspace. Use in place of write(); return 0 or error.
  261.      */
  262.     int (*write_u64)(struct cgroup *cgrp, struct cftype *cft, u64 val);
  263.     /*
  264.      * write_s64() is a signed version of write_u64()
  265.      */
  266.     int (*write_s64)(struct cgroup *cgrp, struct cftype *cft, s64 val);
  267.  
  268.     /*
  269.      * write_string() is passed a nul-terminated kernelspace
  270.      * buffer of maximum length determined by max_write_len.
  271.      * Returns 0 or -ve error code.
  272.      */
  273.     int (*write_string)(struct cgroup *cgrp, struct cftype *cft,
  274.                 const char *buffer);
  275.     /*
  276.      * trigger() callback can be used to get some kick from the
  277.      * userspace, when the actual string written is not important
  278.      * at all. The private field can be used to determine the
  279.      * kick type for multiplexing.
  280.      */
  281.     int (*trigger)(struct cgroup *cgrp, unsigned int event);
  282.  
  283.     int (*release)(struct inode *inode, struct file *file);
  284. };
  285.  
  286. struct cgroup_scanner {
  287.     struct cgroup *cg;
  288.     int (*test_task)(struct task_struct *p, struct cgroup_scanner *scan);
  289.     void (*process_task)(struct task_struct *p,
  290.             struct cgroup_scanner *scan);
  291.     struct ptr_heap *heap;
  292. };
  293.  
  294. /* Add a new file to the given cgroup directory. Should only be
  295.  * called by subsystems from within a populate() method */
  296. int cgroup_add_file(struct cgroup *cgrp, struct cgroup_subsys *subsys,
  297.                const struct cftype *cft);
  298.  
  299. /* Add a set of new files to the given cgroup directory. Should
  300.  * only be called by subsystems from within a populate() method */
  301. int cgroup_add_files(struct cgroup *cgrp,
  302.             struct cgroup_subsys *subsys,
  303.             const struct cftype cft[],
  304.             int count);
  305.  
  306. int cgroup_is_removed(const struct cgroup *cgrp);
  307.  
  308. int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);
  309.  
  310. int cgroup_task_count(const struct cgroup *cgrp);
  311.  
  312. /* Return true if the cgroup is a descendant of the current cgroup */
  313. int cgroup_is_descendant(const struct cgroup *cgrp);
  314.  
  315. /* Control Group subsystem type. See Documentation/cgroups.txt for details */
  316.  
  317. struct cgroup_subsys {
  318.     struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
  319.                           struct cgroup *cgrp);
  320.     void (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
  321.     void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
  322.     int (*can_attach)(struct cgroup_subsys *ss,
  323.               struct cgroup *cgrp, struct task_struct *tsk);
  324.     void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
  325.             struct cgroup *old_cgrp, struct task_struct *tsk);
  326.     void (*fork)(struct cgroup_subsys *ss, struct task_struct *task);
  327.     void (*exit)(struct cgroup_subsys *ss, struct task_struct *task);
  328.     int (*populate)(struct cgroup_subsys *ss,
  329.             struct cgroup *cgrp);
  330.     void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
  331.     void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
  332.     /*
  333.      * This routine is called with the task_lock of mm->owner held
  334.      */
  335.     void (*mm_owner_changed)(struct cgroup_subsys *ss,
  336.                     struct cgroup *old,
  337.                     struct cgroup *new,
  338.                     struct task_struct *p);
  339.     int subsys_id;
  340.     int active;
  341.     int disabled;
  342.     int early_init;
  343. #define MAX_CGROUP_TYPE_NAMELEN 32
  344.     const char *name;
  345.  
  346.     /* Protected by RCU */
  347.     struct cgroupfs_root *root;
  348.  
  349.     struct list_head sibling;
  350. };
  351.  
  352. #define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
  353. #include <linux/cgroup_subsys.h>
  354. #undef SUBSYS
  355.  
  356. static inline struct cgroup_subsys_state *cgroup_subsys_state(
  357.     struct cgroup *cgrp, int subsys_id)
  358. {
  359.     return cgrp->subsys[subsys_id];
  360. }
  361.  
  362. static inline struct cgroup_subsys_state *task_subsys_state(
  363.     struct task_struct *task, int subsys_id)
  364. {
  365.     return rcu_dereference(task->cgroups->subsys[subsys_id]);
  366. }
  367.  
  368. static inline struct cgroup* task_cgroup(struct task_struct *task,
  369.                            int subsys_id)
  370. {
  371.     return task_subsys_state(task, subsys_id)->cgroup;
  372. }
  373.  
  374. int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *ss,
  375.                             char *nodename);
  376.  
  377. /* A cgroup_iter should be treated as an opaque object */
  378. struct cgroup_iter {
  379.     struct list_head *cg_link;
  380.     struct list_head *task;
  381. };
  382.  
  383. /* To iterate across the tasks in a cgroup:
  384.  *
  385.  * 1) call cgroup_iter_start to intialize an iterator
  386.  *
  387.  * 2) call cgroup_iter_next() to retrieve member tasks until it
  388.  *    returns NULL or until you want to end the iteration
  389.  *
  390.  * 3) call cgroup_iter_end() to destroy the iterator.
  391.  *
  392.  * Or, call cgroup_scan_tasks() to iterate through every task in a cpuset.
  393.  *    - cgroup_scan_tasks() holds the css_set_lock when calling the test_task()
  394.  *      callback, but not while calling the process_task() callback.
  395.  */
  396. void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
  397. struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
  398.                     struct cgroup_iter *it);
  399. void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
  400. int cgroup_scan_tasks(struct cgroup_scanner *scan);
  401. int cgroup_attach_task(struct cgroup *, struct task_struct *);
  402.  
  403. void cgroup_mm_owner_callbacks(struct task_struct *old,
  404.                    struct task_struct *new);
  405.  
  406. #else /* !CONFIG_CGROUPS */
  407.  
  408. static inline int cgroup_init_early(void) { return 0; }
  409. static inline int cgroup_init(void) { return 0; }
  410. static inline void cgroup_fork(struct task_struct *p) {}
  411. static inline void cgroup_fork_callbacks(struct task_struct *p) {}
  412. static inline void cgroup_post_fork(struct task_struct *p) {}
  413. static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
  414.  
  415. static inline void cgroup_lock(void) {}
  416. static inline void cgroup_unlock(void) {}
  417. static inline int cgroupstats_build(struct cgroupstats *stats,
  418.                     struct dentry *dentry)
  419. {
  420.     return -EINVAL;
  421. }
  422.  
  423. static inline void cgroup_mm_owner_callbacks(struct task_struct *old,
  424.                          struct task_struct *new) {}
  425.  
  426. #endif /* !CONFIG_CGROUPS */
  427.  
  428. #endif /* _LINUX_CGROUP_H */
  429.